package com.qinke.outtocluster;

import com.ibm.mq.*;
import com.ibm.mq.constants.MQConstants;
import com.qinke.mqcluster.utils.ConfigUtil;

import java.io.IOException;

public class CCQMSender {
    private static String host;
    private static Integer port;
    private static String channel;
    private static String qmgr;
    private static String asyncQueueName;
    private static String syncQueueName;
    private static String repeictQueueName;

    private static void init() {
        host = ConfigUtil.getConfig("HOST");
        port = Integer.valueOf(ConfigUtil.getConfig("PORT"));
        channel = ConfigUtil.getConfig("CHANNEL");
        qmgr = ConfigUtil.getConfig("QMGR");
        asyncQueueName = ConfigUtil.getConfig("ASYNCQUEUE");
        syncQueueName = ConfigUtil.getConfig("SYNCQUEUE");
        repeictQueueName = ConfigUtil.getConfig("REPEICTQUEUENAME");
        StringBuffer lisLog = new StringBuffer();
        lisLog.append(host)
                .append(" : ")
                .append(port)
                .append(" : ")
                .append(channel)
                .append(" : ")
                .append(qmgr)
                .append(" : ")
                .append(asyncQueueName)
                .append(" : ")
                .append(syncQueueName)
                .append(" : ")
                .append(repeictQueueName);
        //配置要使用的队列管理器的信息，这里使用队列管理器CQM1的信息
        MQEnvironment.hostname = host;
        MQEnvironment.port = port;
        MQEnvironment.channel = channel;
        System.out.println("初始化");
        System.out.println("参数:" + lisLog.toString());
    }

    public static void sendAsync() {
        try {
            //创建队列管理器对象，在实例化的时候会隐式连接队列管理器CQM1
            MQQueueManager mqQueueManager = new MQQueueManager(qmgr);
            //定义打开方式
            int openOption = MQConstants.MQOO_OUTPUT; //以写入方式打开
            openOption = openOption + MQConstants.MQOO_BIND_NOT_FIXED;//写入消息方式为不绑定方式（想要负载均衡必须为此方式）
            //直接循环，每次发10条消息
            //创建队列对量
            MQQueue queue = mqQueueManager.accessQueue(asyncQueueName, openOption);
            for (int i = 0; i <= 10; i++) {
                //创建简单消息对象
                MQMessage mqMessage = new MQMessage();
                //将数据写入消息对象中（可自行尝试其他write方法）
                String msg = "简单消息:" + i;
                mqMessage.writeUTF(msg);
                //使用队列发送消息
                queue.put(mqMessage);
                System.out.println("send:" + msg);
            }
            //关闭打开的资源，养成好习惯
            queue.close();
            mqQueueManager.disconnect();
        } catch (MQException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void sendSync() {
        try {
            //创建队列管理器对象，在实例化的时候会隐式连接队列管理器CQM1
            MQQueueManager mqQueueManager = new MQQueueManager(qmgr);
            //定义打开方式
            int openOption = MQConstants.MQOO_OUTPUT; //以写入方式打开
            openOption = openOption + MQConstants.MQOO_BIND_NOT_FIXED;//写入消息方式为不绑定方式（想要负载均衡必须为此方式）
            //直接循环，每次发10条消息
            //创建队列对量
            MQQueue queue = mqQueueManager.accessQueue(syncQueueName, openOption);
            MQPutMessageOptions pmo = new MQPutMessageOptions();
            pmo.options = pmo.options + MQConstants.MQPMO_NEW_MSG_ID;
            pmo.options = pmo.options + MQConstants.MQPMO_SYNCPOINT;

            for (int i = 0; i <= 10; i++) {
                //创建简单消息对象
                MQMessage sendMsg = new MQMessage();
                //将数据写入消息对象中（可自行尝试其他write方法）
                String sendMsgCon = "简单消息:" + i;
                sendMsg.writeUTF(sendMsgCon);
                //设置消息标识为请求消息
                sendMsg.messageFlags = MQConstants.MQMT_REQUEST;
                //设置回执队列与回执队列管理器（当前队列管理器）
                sendMsg.replyToQueueName = repeictQueueName;
                sendMsg.replyToQueueManagerName = qmgr;
                //使用队列发送消息
                queue.put(sendMsg, pmo);
                mqQueueManager.commit();
                System.out.println("发送消息:"+sendMsgCon);
                byte[] messageId = sendMsg.messageId;
                //设置回执队列打开方式
                int getOpenOption = MQConstants.MQOO_INPUT_SHARED | MQConstants.MQOO_FAIL_IF_QUIESCING;
                //创建回执队列对象
                MQQueue mqQueue = mqQueueManager.accessQueue(repeictQueueName, getOpenOption);
                //创建获取消息的对象，并设置消息选择器
                MQMessage getMsg = new MQMessage();
                getMsg.correlationId = messageId;

                MQGetMessageOptions gmo = new MQGetMessageOptions();
                gmo.options = gmo.options + MQConstants.MQGMO_SYNCPOINT;//Get messages under sync point control（在同步点控制下获取消息）
                gmo.options = gmo.options + MQConstants.MQGMO_WAIT;  // Wait if no messages on the Queue（如果在队列上没有消息则等待）
                gmo.options = gmo.options + MQConstants.MQMO_MATCH_CORREL_ID;// Fail if Qeue Manager Quiescing（如果队列管理器停顿则失败）
                gmo.waitInterval = 20000;
                //获取响应消息
                mqQueue.get(getMsg, gmo);
                String getMsgContent = getMsg.readUTF();
                System.out.println("回执消息："+getMsgContent);
                mqQueue.close();

            }
            //关闭打开的资源，养成好习惯
            queue.close();
            mqQueueManager.disconnect();
        } catch (MQException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        init();
        sendSync();
    }
}
